package com.sgcc.epri.dcloud.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.sgcc.epri.dcloud.mapper.dm.TreeMapper;
import com.sgcc.epri.dcloud.pojo.Result;
import com.sgcc.epri.dcloud.pojo.TreeNode;
import com.sgcc.epri.dcloud.service.TreeService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;

@Service
public class TreeServiceImpl implements TreeService {

    private final Logger log =  LoggerFactory.getLogger(this.getClass());

    @Autowired
    private TreeMapper treeMapper;

    @Override
    public Result select() {
        try{
            //查询所有的数据
            List<TreeNode> allList= treeMapper.selectList(null);
            //创建一个list集合，用于存放根节点
            List<TreeNode> parent=new ArrayList<>();
            for(TreeNode person:allList){
                //如果parentId为0，则代表是根节点，存入到集合中
                if(person.getParentId().equals("0")){
                    parent.add(person);
                }
            }
            //查找根节点下的子类，因为根节点的id就是 子节点的parentId;
            for(TreeNode person:parent){
                List<TreeNode> children=getChild(person.getId()+"",allList);
                person.setChildren(children);
            }
            return Result.success(parent);
        }catch (Exception e){
            e.printStackTrace();
            log.error("查询树形结构失败!"+e);
            return Result.error("查询树形结构失败!");
        }
    }

    //查找子节点的方法
    private List<TreeNode> getChild(String id, List<TreeNode> allList) {
        //存放子节点的集合
        List<TreeNode> children=new ArrayList<>();
        for (TreeNode person:allList){
            //如果根节点的id 等于集合内parentid，说明是根节点的子节点
            if(person.getParentId().equals(id)){
                //存入子节点集合
                children.add(person);
            }
        }

        for (TreeNode person:children){
            //递归调用，如果子节点存在根节点，则再次调用，往后依次推
            List<TreeNode> personChildren= getChild(person.getId()+"",allList);
            person.setChildren(personChildren);
        }
        //递归结束条件，如果子节点不存在子节点，则递归结束
        if(children==null){
            return null;
        }
        return children;
    }

    @Override
    public Result insert(TreeNode treeNode) {
        try{
            return Result.success(treeMapper.insert(treeNode));
        }catch (Exception e){
            e.printStackTrace();
            log.error("添加节点失败!"+e);
            return Result.error("添加节点失败!");
        }
    }

    @Override
    public Result update(TreeNode person) {
        try{
            return Result.success(treeMapper.updateById(person));
        }catch (Exception e){
            e.printStackTrace();
            log.error("修改节点失败!"+e);
            return Result.error("修改节点失败!");
        }
    }

    @Transactional
    @Override
    public Result delete(String id) {
        try{
            QueryWrapper<TreeNode> queryWrapper =new QueryWrapper<>();
            queryWrapper.eq("parent_id",id);
            //首先查出当前节点是否存在子节点，如果存在，则遍历删除子节点
            List<TreeNode> personList=treeMapper.selectList(queryWrapper);
            //递归查出所有的子节点，personList为null是递归结束条件，如果当前子节点还存在子节点，则再次执行当前方法，只到找到不存子节点的那项结束
            if(personList!=null&&personList.size()>0){
                for (TreeNode treeNode:personList){
                    delete(treeNode.getId()+"");
                }
            }
            return Result.success(treeMapper.deleteById(id));
        }catch (Exception e){
            e.printStackTrace();
            log.error("删除节点失败！"+e);
            return Result.error("删除节点失败");
        }
    }

}
